//ADPCM-DIV4 音频帧标识头
struct adpcm_state
{
      //前一个采用点值：adpcm算法是根据前一个采样点为基准值，求后续压缩值
    short     valprev;    
    char     index;
    char     rev;
};


/* Intel ADPCM step variation table */
static int indexTable[16] = {
    -1, -1, -1, -1, 2, 4, 6, 8,
    -1, -1, -1, -1, 2, 4, 6, 8,
};

static int stepsizeTable[89] = {
    7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
    19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
    50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
    130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
    337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
    876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
    2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
    5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
    15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
};


/*
len:    表示采用点数。如16位音频采用一个点是2个字节，但是长度是1
*/
int adpcm_coder(short *indata, signed char *outdata, int len, struct adpcm_state *state)
{
    short *inp;            /* Input buffer pointer */
    signed char *outp;        /* output buffer pointer */
    int val;            /* Current input sample value */
    int sign;            /* Current adpcm sign bit */
    int delta;            /* Current adpcm output value */
    int diff;            /* Difference between val and valprev */
    int step;            /* Stepsize */
    int valpred;        /* Predicted output value */
    int vpdiff;            /* Current change to valpred */
    int index;            /* Current step change index */
    int outputbuffer;        /* place to keep previous 4-bit value */
    int bufferstep;        /* toggle between outputbuffer/output */
        int outLen = 0;
    outp = (signed char *)outdata;
    inp = indata;

    valpred = state->valprev;
    index = state->index;
    step = stepsizeTable[index];
    
    bufferstep = 1;

    for ( ; len > 0 ; len-- ) {
        val = *inp++;
        
    /* Step 1 - compute difference with previous value */
    diff = val - valpred;
    sign = (diff < 0) ? 8 : 0;
    if ( sign ) diff = (-diff);

    /* Step 2 - Divide and clamp */
    /* Note:
    ** This code *approximately* computes:
    **    delta = diff*4/step;
    **    vpdiff = (delta+0.5)*step/4;
    ** but in shift step bits are dropped. The net result of this is
    ** that even if you have fast mul/div hardware you cannot put it to
    ** good use since the fixup would be too expensive.
    */
    delta = 0;
    vpdiff = (step >> 3);
    
    if ( diff >= step ) {
        delta = 4;
        diff -= step;
        vpdiff += step;
    }
    step >>= 1;
    if ( diff >= step  ) {
        delta |= 2;
        diff -= step;
        vpdiff += step;
    }
    step >>= 1;
    if ( diff >= step ) {
        delta |= 1;
        vpdiff += step;
    }
    /* Step 3 - Update previous value */
    if ( sign )
      valpred -= vpdiff;
    else
      valpred += vpdiff;

    /* Step 4 - Clamp previous value to 16 bits */
    if ( valpred > 32767 )
      valpred = 32767;
    else if ( valpred < -32768 )
      valpred = -32768;

    /* Step 5 - Assemble value, update index and step values */
    delta |= sign;
    
    index += indexTable[delta];
    if ( index < 0 ) index = 0;
    if ( index > 88 ) index = 88;
    step = stepsizeTable[index];
    /* Step 6 - Output value   adpcm_div4
    if ( bufferstep ) {
        outputbuffer = (delta << 4) & 0xf0;
    } else {
        *outp++ = (delta & 0x0f) | outputbuffer;

       outLen++;
    }*/

    //adpcm_ima
    if ( bufferstep ) {
        outputbuffer = delta & 0x0f;
    } else {
        *outp++ = ((delta << 4) & 0xf0) | outputbuffer;
        outLen++;
    }
    bufferstep = !bufferstep;
    }

    /* Output last step, if needed */
    if ( !bufferstep )
    {
      *outp++ = outputbuffer;
      outLen++;
    }
    
    state->valprev = valpred;
    state->index = index;

    return outLen;
}


//16位 adpcm转pcm
int adpcm_decode(char*inbuff,char*outbuff,int in_len)
{
    struct adpcm_state adpcmState;
    adpcmState.index =inbuff[2];
    adpcmState.valprev =(short)inbuff[0]+((short)(inbuff[1]))*256;   //每一个block里面帧头有一个未压缩的数据 存储时 先低后高
    struct adpcm_state *state = &adpcmState;
    inbuff += 4;
    in_len -= 4;

    int  i=0,j=0;
  char tmp_data;
  long step;/* Quantizer step size */
  signed long predsample;/* Output of ADPCM predictor */
  signed long diffq;/* Dequantized predicted difference */
  int index;/* Index into step size table */

  int Samp;
  unsigned char SampH,SampL;
  unsigned char inCode;

  /* Restore previous values of predicted sample and quantizer step
  size index
  */
  predsample =state->valprev;
  index =state->index;
     if(index <0)
        index =0;
    if(index >88)
        index =88;
    for(i=0;i<in_len*2;i++)
    {
        tmp_data=inbuff[i/2];  

        //adpcm_ima
        if(i%2)
            inCode=(tmp_data&0xf0)>>4;
        else
            inCode=tmp_data &0x0f;
        /*adpcm_div4

         if(i%2)
            inCode=tmp_data &0x0f;
        else
            inCode=(tmp_data&0xf0)>>4;

        */
        step =stepsizeTable[index];
        /* Inverse quantize the ADPCM code into a predicted difference
        using the quantizer step size
        */
    
        diffq =step >>3;
        if(inCode &4)
            diffq +=step;
        if(inCode &2)
            diffq +=step >>1;
        if(inCode &1)
            diffq +=step >>2;
        /* Fixed predictor computes new predicted sample by adding the
        old predicted sample to predicted difference
        */
        if(inCode &8)
            predsample -=diffq;
        else
            predsample +=diffq;
        /* Check for overflow of the new predicted sample
        */
        if(predsample >32767)
            predsample =32767;
        else if(predsample <-32768)
            predsample =-32768;
        /* Find new quantizer stepsize index by adding the old index
        to a table lookup using the ADPCM code
        */
        index +=indexTable[inCode];
        /* Check for overflow of the new quantizer step size index
        */
        if(index <0)
            index =0;
        if(index >88)
            index =88;

        /* Return the new ADPCM code */
        Samp=predsample;
        if(Samp>=0)
        {
            SampH=Samp/256;
            SampL=Samp-256*SampH;
        }
        else
        {
            Samp=32768+Samp;
            SampH=Samp/256;
            SampL=Samp-256*SampH;
            SampH+=0x80;
        }

        outbuff[j++]=SampL;
        outbuff[j++]=SampH;   
    //    hEncoder = NULL;
    } 
    /* Save the predicted sample and quantizer step size index for
     next iteration
     */
    state->valprev =(short)predsample;
    state->index =(char)index;
    return j;
}
